// order-detail.js
const app = getApp()

Page({
  data: {
    orderId: null,
    order: null,
    loading: true,
    userInfo: {
      isLogin: false
    }
  },

  onLoad(options) {
    console.log('订单详情页面加载，接收到的参数:', options)
    console.log('订单ID:', options.id)
    
    if (!options.id) {
      wx.showModal({
        title: '参数错误',
        content: '订单ID不存在，无法查看订单详情',
        showCancel: false,
        confirmText: '返回',
        success: () => {
          wx.navigateBack()
        }
      })
      return
    }
    
    this.setData({ orderId: options.id })
    this.loadUserInfo()
    this.loadOrderDetail()
  },

  // 加载用户信息
  loadUserInfo() {
    const globalUserInfo = app.getUserInfo()
    this.setData({ userInfo: globalUserInfo })
  },

  // 加载订单详情
  loadOrderDetail() {
    this.setData({ loading: true })
    this.getOrderDetailFromAPI()
  },

  // 从API获取订单详情
  getOrderDetailFromAPI() {
    console.log('开始调用订单详情API，订单ID:', this.data.orderId)
    console.log('API请求URL:', `http://localhost:8081/product/OrderById?id=${this.data.orderId}`)
    
    if (!this.data.orderId) {
      console.error('订单ID为空，无法调用API')
      wx.showModal({
        title: '参数错误',
        content: '订单ID为空，无法获取订单详情',
        showCancel: false,
        confirmText: '返回',
        success: () => {
          wx.navigateBack()
        }
      })
      return
    }
    
    wx.request({
      url: `http://localhost:8081/product/OrderById?id=${this.data.orderId}`,
      method: 'GET',
      header: {
        'Content-Type': 'application/json'
      },
      success: (res) => {
        console.log('订单详情API响应状态码:', res.statusCode)
        console.log('订单详情API响应:', res.data)
        this.setData({ loading: false })
        
        if (res.statusCode === 200 && res.data) {
          const orderData = res.data
          console.log('订单详情数据:', orderData)
          
          // 处理订单数据
          this.processOrderData(orderData)
        } else {
          console.log('API返回错误:', res.data)
          wx.showModal({
            title: '获取订单详情失败',
            content: res.data.message || res.data.error || '订单不存在或已被删除',
            showCancel: false,
            confirmText: '返回',
            success: () => {
              wx.navigateBack()
            }
          })
        }
      },
      fail: (err) => {
        console.error('获取订单详情失败:', err)
        this.setData({ loading: false })
        wx.showModal({
          title: '网络错误',
          content: '无法连接到服务器，请检查网络连接后重试',
          showCancel: false,
          confirmText: '返回',
          success: () => {
            wx.navigateBack()
          }
        })
      }
    })
  },

  // 处理订单数据
  processOrderData(orderData) {
    console.log('处理订单数据:', orderData)
    
    // 处理商品信息
    const product = orderData.product || {}
    const items = [{
      id: product.id || orderData.productid,
      name: product.name || '商品名称',
      image: product.cover || 'https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&h=400&fit=crop&crop=center',
      price: product.price || orderData.totalAmount,
      quantity: 1,
      totalPrice: orderData.payAmount || orderData.totalAmount,
      intro: product.intro || '',
      detail: product.detail || ''
    }]
    
    // 处理用户信息（收货地址）
    const user = orderData.user || {}
    const address = {
      receiver: user.nickname || user.username || '用户',
      phone: user.phone || '',
      fullAddress: user.residentAddress || '地址未设置',
      avatar: user.avatar || ''
    }
    
    // 处理订单信息
    const order = {
      id: orderData.id,
      orderNo: orderData.orderNo,
      status: orderData.status,
      statusText: this.getStatusText(orderData.status),
      totalAmount: orderData.totalAmount,
      payAmount: orderData.payAmount,
      discountAmount: orderData.discountAmount || 0,
      payType: orderData.payType,
      payTypeText: this.getPayTypeText(orderData.payType),
      createTime: this.formatTime(orderData.createTime),
      payTime: orderData.payTime ? this.formatTime(orderData.payTime) : null,
      updateTime: this.formatTime(orderData.updateTime),
      items: items,
      address: address, // 使用真实用户地址
      user: user // 保存完整用户信息
    }
    
    console.log('处理后的订单数据:', order)
    console.log('用户信息:', user)
    console.log('收货地址:', address)
    console.log('收货人:', address.receiver)
    console.log('联系电话:', address.phone)
    console.log('详细地址:', address.fullAddress)
    
    this.setData({ order })
  },



  // 获取状态文本
  getStatusText(status) {
    const statusMap = {
      'pending': '待付款',
      'paid': '已支付',
      'cancelled': '已取消'
    }
    return statusMap[status] || '未知状态'
  },

  // 获取支付方式文本
  getPayTypeText(payType) {
    const payTypeMap = {
      'wechat': '微信支付',
      'alipay': '支付宝',
      'bank': '银行卡'
    }
    return payTypeMap[payType] || '未知支付方式'
  },

  // 格式化时间
  formatTime(timeStr) {
    if (!timeStr) return ''
    
    try {
      const date = new Date(timeStr)
      const year = date.getFullYear()
      const month = String(date.getMonth() + 1).padStart(2, '0')
      const day = String(date.getDate()).padStart(2, '0')
      const hours = String(date.getHours()).padStart(2, '0')
      const minutes = String(date.getMinutes()).padStart(2, '0')
      const seconds = String(date.getSeconds()).padStart(2, '0')
      
      return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
    } catch (error) {
      return timeStr
    }
  },

  // 支付订单
  onPayOrder() {
    const order = this.data.order
    if (!order) return
    
    // 直接跳转到支付宝支付页面
    this.goToAlipayPayment(order)
  },

  // 跳转到支付宝支付页面
  goToAlipayPayment(order) {
    // 准备支付页面需要的数据
    const alipayOrderData = {
      id: order.id,
      orderNo: order.orderNo,
      subject: order.items && order.items.length > 0 ? order.items[0].name : '商品',
      amount: order.totalAmount,
      payAmount: order.payAmount,
      createTime: order.createTime
    }
    
    // 存储订单数据到本地
    wx.setStorageSync('alipayOrderData', alipayOrderData)
    
    // 跳转到支付宝支付页面
    wx.navigateTo({
      url: '/pages/alipay-payment/alipay-payment',
      success: () => {
        console.log('跳转到支付宝支付页面成功')
      },
      fail: (err) => {
        console.error('跳转到支付宝支付页面失败:', err)
        wx.showToast({
          title: '跳转支付页面失败',
          icon: 'none'
        })
      }
    })
  },


  // 处理支付
  processPayment(order, payType) {
    wx.showLoading({
      title: '正在支付...'
    })
    
    // 调用真实的支付API
    this.callPaymentAPI(order, payType)
  },

  // 调用支付API
  callPaymentAPI(order, payType) {
    const token = wx.getStorageSync('token')
    if (!token) {
      wx.hideLoading()
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      return
    }

    // 根据支付方式选择API
    const apiUrl = payType === 'alipay' 
      ? 'http://localhost:8081/api/productpay/pay'
      : 'http://localhost:8081/api/wechatpay/pay' // 微信支付API，需要实现

    wx.request({
      url: apiUrl,
      method: 'POST',
      header: {
        'Content-Type': 'application/json',
        'token': token
      },
      data: {
        id: order.id
      },
      success: (res) => {
        wx.hideLoading()
        
        console.log('支付API响应:', res.data)
        
        if (res.data && res.data.code === 200) {
          // 支付成功，跳转到支付页面
          if (payType === 'alipay') {
            // 支付宝支付，存储支付数据并跳转到二维码支付页面
            const paymentData = {
              orderNo: res.data.orderNo,
              amount: res.data.amount,
              subject: res.data.subject,
              paymentUrl: res.data.paymentUrl
            }
            
            // 存储支付数据到本地
            wx.setStorageSync('paymentData', paymentData)
            wx.setStorageSync('currentOrderId', order.id)
            
            // 跳转到二维码支付页面
            wx.navigateTo({
              url: '/pages/payment-qr/payment-qr',
              fail: () => {
                wx.showToast({
                  title: '跳转支付页面失败',
                  icon: 'none'
                })
              }
            })
          } else {
            // 微信支付，调用微信支付API
            this.callWechatPay(res.data.paymentUrl || res.data.data)
          }
        } else {
          wx.showToast({
            title: res.data?.message || '支付失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('支付API调用失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },

  // 调用微信支付
  callWechatPay(paymentData) {
    // 这里需要实现微信支付逻辑
    // 由于微信支付需要特殊的处理，这里先显示提示
    wx.showToast({
      title: '微信支付功能开发中',
      icon: 'none'
    })
  },

  // 取消订单
  onCancelOrder() {
    const order = this.data.order
    if (!order) return
    
    // 检查订单状态，只有待付款的订单才能取消
    if (order.status !== 'pending') {
      wx.showToast({
        title: '只有待付款订单才能取消',
        icon: 'none'
      })
      return
    }
    
    wx.showModal({
      title: '取消订单',
      content: `确定要取消订单 ${order.orderNo} 吗？\n取消后将无法恢复。`,
      confirmText: '确认取消',
      cancelText: '再想想',
      success: (res) => {
        if (res.confirm) {
          this.cancelOrderAPI(order.id)
        }
      }
    })
  },

  // 调用取消订单API
  cancelOrderAPI(orderId) {
    console.log('开始取消订单，订单ID:', orderId)
    
    wx.showLoading({
      title: '正在取消订单...'
    })
    
    wx.request({
      url: `http://localhost:8081/product/OrderQuxiao?id=${orderId}`,
      method: 'POST',
      header: {
        'Content-Type': 'application/json'
      },
      success: (res) => {
        wx.hideLoading()
        console.log('取消订单API响应:', res.data)
        
        if (res.statusCode === 200 && res.data) {
          // 取消成功，更新订单状态
          this.setData({
            'order.status': 'cancelled',
            'order.statusText': '已取消',
            'order.updateTime': this.formatTime(new Date().toISOString())
          })
          
          wx.showToast({
            title: '订单取消成功',
            icon: 'success'
          })
          
          // 延迟跳转到订单列表页面
          setTimeout(() => {
            wx.navigateTo({
              url: '/pages/order/order',
              success: () => {
                console.log('跳转到订单列表页面成功')
              },
              fail: (err) => {
                console.error('跳转到订单列表页面失败:', err)
                // 如果跳转失败，返回上一页
                wx.navigateBack()
              }
            })
          }, 1500)
        } else {
          console.error('取消订单失败:', res.data)
          wx.showModal({
            title: '取消订单失败',
            content: res.data.message || res.data.error || '请稍后重试',
            showCancel: false,
            confirmText: '确定'
          })
        }
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('取消订单失败:', err)
        wx.showModal({
          title: '网络错误',
          content: '取消订单失败，请检查网络连接后重试',
          showCancel: false,
          confirmText: '确定'
        })
      }
    })
  },

  // 联系客服
  onContactService() {
    wx.showModal({
      title: '联系客服',
      content: '客服电话：400-123-4567\n工作时间：9:00-18:00',
      showCancel: false,
      confirmText: '知道了'
    })
  },

  // 复制订单号
  onCopyOrderNo() {
    const order = this.data.order
    if (!order) return
    
    wx.setClipboardData({
      data: order.orderNo,
      success: () => {
        wx.showToast({
          title: '订单号已复制',
          icon: 'success'
        })
      }
    })
  },

  // 返回上一页
  onBack() {
    wx.navigateBack()
  },

  // 商品点击事件
  onItemTap(e) {
    const item = e.currentTarget.dataset.item
    if (!item) return
    
    // 跳转到商品详情页面
    wx.navigateTo({
      url: `/pages/product-detail/product-detail?id=${item.id}`,
      fail: () => {
        wx.showToast({
          title: '商品详情页面不存在',
          icon: 'none'
        })
      }
    })
  },

  // 再次购买
  onBuyAgain() {
    const order = this.data.order
    if (!order || !order.items || order.items.length === 0) return
    
    const item = order.items[0] // 取第一个商品
    wx.navigateTo({
      url: `/pages/product-detail/product-detail?id=${item.id}`,
      fail: () => {
        wx.showToast({
          title: '商品详情页面不存在',
          icon: 'none'
        })
      }
    })
  },

  // 申请退款
  onRefund() {
    const order = this.data.order
    if (!order) return
    
    wx.showModal({
      title: '申请退款',
      content: `确定要申请退款订单 ${order.orderNo} 吗？\n退款金额：¥${order.payAmount}`,
      success: (res) => {
        if (res.confirm) {
          wx.showLoading({
            title: '正在申请退款...'
          })
          
          // 模拟退款申请
          setTimeout(() => {
            wx.hideLoading()
            wx.showToast({
              title: '退款申请已提交',
              icon: 'success'
            })
          }, 1500)
        }
      }
    })
  },

  // 查看物流
  onViewLogistics() {
    wx.showToast({
      title: '物流功能开发中',
      icon: 'none'
    })
  },

  // 确认收货
  onConfirmReceipt() {
    const order = this.data.order
    if (!order) return
    
    wx.showModal({
      title: '确认收货',
      content: `确定已收到订单 ${order.orderNo} 的商品吗？`,
      success: (res) => {
        if (res.confirm) {
          wx.showLoading({
            title: '正在确认收货...'
          })
          
          // 模拟确认收货
          setTimeout(() => {
            wx.hideLoading()
            this.setData({
              'order.status': 'delivered',
              'order.statusText': '已送达'
            })
            wx.showToast({
              title: '确认收货成功',
              icon: 'success'
            })
          }, 1500)
        }
      }
    })
  }
})
